package com.jeesite.modules.stock.service;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.Date;
import java.util.List;

import com.jeesite.modules.dp.entity.column.DpColumn;
import com.jeesite.modules.stock.dto.UserColumnCheckedChangeDTO;
import com.jeesite.modules.utils.CommonUtils;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.jeesite.common.lang.StringUtils;
import com.jeesite.modules.stock.dao.UserColumnsDao;
import com.jeesite.modules.stock.dto.UserColumnsAddDTO;
import com.jeesite.modules.stock.entity.UserColumnsEntity;
import org.springframework.web.bind.annotation.RequestBody;

@Slf4j
@Service
public class UserColumnsService {

    @Autowired
    private UserColumnsDao userColumnsDao;

    /**
     * 删除已被移除的字段
     *
     * @param userId     用户id
     * @param allColumns 所有可用字段
     */
    private void deleteUnExistColumn(String userId, List<DpColumn> allColumns, List<UserColumnsEntity> userColumns) {
        List<String> allColumnKeys = allColumns.stream().map(DpColumn::getColumnKey).toList();
        List<String> deleteColumnKeys = new ArrayList<>();
        if (userColumns != null && !userColumns.isEmpty()) {
            for (UserColumnsEntity userColumn : userColumns) {
                if (!allColumnKeys.contains(userColumn.getColumnKey())) {
                    userColumnsDao.deleteUserColumn(userId, userColumn.getColumnKey());
                    deleteColumnKeys.add(userColumn.getColumnKey());
                }
            }
        }
        if (userColumns != null) {
            userColumns.removeIf(item -> deleteColumnKeys.contains(item.getColumnKey()));
        }
    }

    private List<DpColumn> filterAllowColumns(List<DpColumn> columns) {
        List<DpColumn> allowColumns = new ArrayList<>();
        for (DpColumn column : columns) {
            if (CommonUtils.isTrue(column.getIscol())
                    && !StringUtils.isBlank(column.getColumnKey())
                    && !StringUtils.isBlank(column.getColumnName())) {
                allowColumns.add(column);
            }
        }
        allowColumns.sort(Comparator.comparing(DpColumn::getSort));
        return allowColumns;
    }

    private boolean isChange(UserColumnsEntity userColumn, DpColumn dpColumn) {
        if (!userColumn.getColumnKey().equals(dpColumn.getColumnKey())) {
            return true;
        }
        if (!userColumn.getColumnDataindex().equals(dpColumn.getColumnDataindex())) {
            return true;
        }
        if (!userColumn.getColumnName().equals(dpColumn.getColumnName())) {
            return true;
        }
        if (!String.valueOf(userColumn.getColumnType()).equals(dpColumn.getType())) {
            return true;
        }
        return !String.valueOf(userColumn.getIsSort()).equals(dpColumn.getIsSort());
    }

    /**
     * 初始化用户的列表字段，默认为dp_column表中所有is_col=1
     *
     * @param userId 用户id
     */
    public void initUserColumns(String userId, List<DpColumn> columns) {
        long time = System.currentTimeMillis();
        if (columns != null && !columns.isEmpty()) {
            List<DpColumn> allowColumns = filterAllowColumns(columns);
            List<UserColumnsEntity> userColumns = userColumnsDao.findUserColumns(userId);
            deleteUnExistColumn(userId, allowColumns, userColumns);

            List<UserColumnsEntity> insertColumns = new ArrayList<>();
            List<UserColumnsEntity> updateColumns = new ArrayList<>();
            int size = allowColumns.size();
            for (DpColumn column : allowColumns) {
                boolean newRecord = false;
                UserColumnsEntity userColumn = userColumns.stream()
                        .filter(item -> item.getColumnKey().equals(column.getColumnKey()))
                        .findFirst()
                        .orElse(null);
                if (userColumn == null) {
                    userColumn = new UserColumnsEntity();
                    userColumn.setCreateDate(new Date());
                    userColumn.setUpdateDate(new Date());
                    userColumn.setUserId(userId);
                    userColumn.setChecked(StringUtils.isBlank(column.getIsShow()) ? 0 : Integer.parseInt(column.getIsShow()));
                    int sn = StringUtils.isBlank(column.getSort()) ? size++ : Integer.parseInt(column.getSort());
                    userColumn.setSn(sn);
                    userColumn.setDefaultSn(sn);
                    newRecord = true;

                } else {
                    if (!isChange(userColumn, column)) {
                        continue;
                    }
                }
                userColumn.setColumnDataindex(column.getColumnDataindex());
                userColumn.setColumnKey(column.getColumnKey());
                userColumn.setColumnName(column.getColumnName());
                userColumn.setColumnType(column.getType());
                userColumn.setIsSort(StringUtils.isBlank(column.getIsSort()) ? 0 : Integer.parseInt(column.getIsSort()));
                if (newRecord) {
                    insertColumns.add(userColumn);
                } else {
                    updateColumns.add(userColumn);
                }
            }
            if (!insertColumns.isEmpty()) {
                userColumnsDao.insertBatch(insertColumns);
            }
            if (!updateColumns.isEmpty()) {
                userColumnsDao.updateBatch(updateColumns);
            }
        }
        log.info("初始化字段，耗时：{}ms", System.currentTimeMillis() - time);
    }

    /**
     * 存储用户字段
     *
     * @param param 参数
     */
    public void updateColumnSn(UserColumnsAddDTO param) {
        List<UserColumnsEntity> userColumns = userColumnsDao.findUserColumns(param.getUserId());
        userColumns.removeIf(item -> !param.getColumns().contains(item.getColumnKey()));
        for (UserColumnsEntity userColumn : userColumns) {
            userColumn.setSn(param.getColumns().indexOf(userColumn.getColumnKey()));
        }
        userColumnsDao.updateBatch(userColumns);
    }

    public void updateColumnChecked(@RequestBody UserColumnCheckedChangeDTO dto) {
        UserColumnsEntity column = userColumnsDao.findUserColumn(dto.getUserId(), dto.getColumnKey());
        if (column != null) {
            column.setChecked(dto.getChecked());
            userColumnsDao.update(column);
        }
    }

    /**
     * 查询用户字段配置
     *
     * @param userId 用户id
     */
    public List<UserColumnsEntity> getUserColumns(String userId) {
        return userColumnsDao.findUserColumns(userId);
    }

    /**
     * 该用户是否存在自己配置的column
     *
     * @param userId 用户id
     * @return 存在返回true
     */
    public boolean hasUserColumns(String userId) {
        return userColumnsDao.count(userId) > 0;
    }
}
